home *** CD-ROM | disk | FTP | other *** search
/ Internet Publisher's Toolbox 2.0 / Internet Publisher's Toolbox.iso / internet / ntserver / wtsource / zutil.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-03-08  |  23.8 KB  |  1,052 lines
  1. /* WIDE AREA INFORMATION SERVER SOFTWARE:
  2.    No guarantees or restrictions.  See the readme file for the full standard
  3.    disclaimer.  
  4. */
  5.  
  6. /* Copyright (c) CNIDR (see ../COPYRIGHT) */
  7.  
  8. #ifndef lint
  9. static char *RCSid = "$Header: /usr/users/freewais/FreeWAIS-0.1/ir/zutil.c,v 1.1 1993/02/16 15:05:35 freewais Exp $";
  10. #endif
  11.  
  12. /* Change log:
  13.  * $Log: zutil.c,v $
  14.  * Revision 1.1  1993/02/16  15:05:35  freewais
  15.  * Initial revision
  16.  *
  17.  * Revision 1.6  92/03/26  18:27:16  jonathan
  18.  * Fixed function declaration.
  19.  * 
  20.  * Revision 1.5  92/03/07  19:41:14  jonathan
  21.  * ANSIfied argument list.
  22.  * 
  23.  * Revision 1.4  92/02/12  14:01:37  jonathan
  24.  * Added "$Log" so RCS will put the log message in the header
  25.  * 
  26.  *
  27.    3.26.90      Harry Morris, morris@think.com
  28.    3.30.90  Harry Morris - Changed any->bits to any->bytes
  29.    4.11.90  HWM - fixed include file names, changed 
  30.                                 - writeCompressedIntegerWithPadding() to
  31.                   writeCompressedIntWithPadding()
  32.                 - generalized conditional includes (see c-dialect.h)
  33.    3.7.91   Jonny Goldman.  Replaced "short" in makeBitMap with "int" line 632.
  34. */
  35.  
  36. #define _C_utils_Z39_50_
  37.  
  38. #include "zutil.h"
  39.  
  40. #include <math.h>
  41. #include <string.h>
  42.  
  43. char* readErrorPosition = NULL; /* pos where buf stoped making sense */
  44.  
  45. /*----------------------------------------------------------------------*/
  46. /* A note on error handling 
  47.    read - these are low level routines, they do not check the type tags
  48.    which (sometimes) preceed the data (this is done by the higher
  49.    level functions which call these functions).  There is no 
  50.    attempt made to check that the reading does not exceed the read
  51.    buffer.  Such cases should be very rare and usually will be 
  52.    caught by the calling functions. (note - it is unlikely that 
  53.    a series of low level reads will go far off the edge without
  54.    triggering a type error.  However, it is possible for a single
  55.    bad read in an array function (eg. readAny) to attempt to read a 
  56.    large ammount, possibly causing a segmentation violation or out
  57.    of memory condition.
  58.  */
  59. /*----------------------------------------------------------------------*/
  60.  
  61. diagnosticRecord* 
  62. makeDiag(surrogate,code,addInfo)
  63. boolean surrogate;
  64. char* code;
  65. char* addInfo;
  66. {
  67.   diagnosticRecord* diag = 
  68.     (diagnosticRecord*)s_malloc((size_t)sizeof(diagnosticRecord));
  69.   
  70.   diag->SURROGATE = surrogate;
  71.   memcpy(diag->DIAG,code,DIAGNOSTIC_CODE_SIZE);
  72.   diag->ADDINFO = s_strdup(addInfo); 
  73.  
  74.   return(diag);
  75. }
  76.  
  77. /*----------------------------------------------------------------------*/
  78.  
  79. void 
  80. freeDiag(diag)
  81. diagnosticRecord* diag;
  82. { 
  83.   if (diag != NULL)
  84.     { if (diag->ADDINFO != NULL)
  85.         s_free(diag->ADDINFO);
  86.         s_free(diag);
  87.       }
  88. }
  89.  
  90. /*----------------------------------------------------------------------*/
  91.  
  92. #define END_OF_RECORD   0x1D
  93.  
  94. char* 
  95. writeDiag(diag,buffer,len)
  96. diagnosticRecord* diag;
  97. char* buffer;
  98. long* len;
  99. /* diagnostics (as per Appendix D) have a very weird format - this changes
  100.    in SR-1
  101.  */
  102. {
  103.   char* buf = buffer;
  104.   long  length;
  105.   
  106.   if (diag == NULL)             /* handle unspecified optional args */
  107.     return(buf);
  108.  
  109.   buf = writeTag(DT_DatabaseDiagnosticRecords,buf,len);
  110.   CHECK_FOR_SPACE_LEFT(0L,len);
  111.   
  112.   length = 3; 
  113.   if (diag->ADDINFO != NULL)
  114.     length += strlen(diag->ADDINFO);
  115.     
  116.   if (length >= 0xFFFF )        /* make sure the length is reasonable */
  117.     { length = 0xFFFF - 1;
  118.       diag->ADDINFO[0xFFFF - 3 - 1] = '\0';
  119.     }
  120.    
  121.   buf = writeBinaryInteger(length,2L,buf,len);
  122.  
  123.   CHECK_FOR_SPACE_LEFT(1L,len);
  124.   buf[0] = diag->DIAG[0]; 
  125.   buf++;
  126.   
  127.   CHECK_FOR_SPACE_LEFT(1L,len);
  128.   buf[0] = diag->DIAG[1];
  129.   buf++;
  130.   
  131.   if (length > 3)
  132.     { CHECK_FOR_SPACE_LEFT(3L,len);
  133.       memcpy(buf,diag->ADDINFO,(size_t)length - 3);
  134.       buf += length - 3;
  135.     }
  136.    
  137.   CHECK_FOR_SPACE_LEFT(1L,len);
  138. #ifdef WIN32
  139.   buf[0] = (char)(diag->SURROGATE);
  140. #else
  141.   buf[0] = diag->SURROGATE;
  142. #endif
  143.   buf++;
  144.   
  145.   CHECK_FOR_SPACE_LEFT(1L,len);
  146.   buf[0] = END_OF_RECORD;
  147.   buf++;
  148.  
  149.   return(buf);
  150. }
  151.  
  152. /*----------------------------------------------------------------------*/
  153.  
  154. char* 
  155. readDiag(diag,buffer)
  156. diagnosticRecord** diag;
  157. char* buffer;
  158. {
  159.   char* buf = buffer;
  160.   diagnosticRecord* d 
  161.     = (diagnosticRecord*)s_malloc((size_t)sizeof(diagnosticRecord));
  162.   data_tag tag;
  163.   long len;
  164.   
  165.   buf = readTag(&tag,buf);
  166.   
  167.   buf = readBinaryInteger(&len,2L,buf);
  168.   
  169.   d->DIAG[0] = buf[0];
  170.   d->DIAG[1] = buf[1];
  171.   d->DIAG[2] = '\0';
  172.     
  173.   if (len > 3)
  174.     { d->ADDINFO = (char*)s_malloc((size_t)(len - 3 + 1));
  175.       memcpy(d->ADDINFO,(char*)(buf + 2),(size_t)(len - 3));
  176.       d->ADDINFO[len - 3] = '\0';
  177.     }
  178.   else
  179.     d->ADDINFO = NULL;
  180.     
  181.   d->SURROGATE = buf[len - 1];
  182.   
  183.   *diag = d;
  184.  
  185.   return(buf + len + 1);
  186. }
  187.  
  188. /*----------------------------------------------------------------------*/
  189.  
  190. #define continueBit     0x80
  191. #define dataMask        0x7F
  192. #define dataBits        7
  193.  
  194. char*
  195. writeCompressedInteger(num,buf,len)
  196. unsigned long num;
  197. char* buf;
  198. long* len;
  199. /* write a binary integer in the format described on p. 40.
  200.    this might be sped up 
  201. */
  202. {
  203.   char byte;
  204.   long i;
  205.   unsigned long size;
  206.   
  207.   size = writtenCompressedIntSize(num);
  208. #ifdef WIN32
  209.   CHECK_FOR_SPACE_LEFT((long)size,len);
  210.   
  211.   for (i = size - 1; i >= 0; i--)
  212.     { byte = (char)(num & dataMask);
  213.       if (i != (long)(size-1))        /* turn on continue bit */
  214. #else
  215.   CHECK_FOR_SPACE_LEFT(size,len);
  216.   
  217.   for (i = size - 1; i >= 0; i--)
  218.     { byte = num & dataMask;
  219.       if (i != (size-1))        /* turn on continue bit */
  220. #endif
  221.         byte = (char)(byte | continueBit);
  222.       buf[i] = byte;
  223.       num = num >> dataBits;    /* don't and here */
  224.     }
  225.    
  226.   return(buf + size);
  227. } 
  228.  
  229. /*----------------------------------------------------------------------*/
  230.  
  231. char*
  232. readCompressedInteger(num,buf)
  233. unsigned long *num;
  234. char* buf;
  235. /* read a binary integer in the format described on p. 40.
  236.    this might be sped up 
  237. */
  238. {
  239.   long i = 0;
  240.   unsigned char byte;
  241.  
  242.   *num = 0;
  243.   
  244.   do 
  245.     { byte = buf[i++];
  246.       *num = *num << dataBits;
  247.       *num += (byte & dataMask);
  248.     }
  249.   while (byte & continueBit);
  250.  
  251.   return(buf + i);
  252. } 
  253.  
  254. /*----------------------------------------------------------------------*/
  255.  
  256. #define pad     128 /* high bit is set */
  257.  
  258. char*
  259. writeCompressedIntWithPadding(num,size,buffer,len)
  260. unsigned long num;
  261. unsigned long size;
  262. char* buffer;
  263. long* len;
  264. /* Like writeCompressedInteger, except writes padding (128) to make
  265.    sure that size bytes are used.  This can be read correctly by 
  266.    readCompressedInteger()
  267. */
  268. {
  269.   char* buf = buffer;
  270.   unsigned long needed,padding;
  271.   long i;
  272.     
  273. #ifdef WIN32
  274.   CHECK_FOR_SPACE_LEFT((long)size,len);
  275. #else
  276.   CHECK_FOR_SPACE_LEFT(size,len);
  277. #endif
  278.   
  279.   needed = writtenCompressedIntSize(num);
  280.   padding = size - needed;
  281.   i = padding - 1;
  282.  
  283.   for (i = padding - 1;i >= 0;i--)
  284. #ifdef WIN32
  285.     { buf[i] = (char)pad;
  286. #else
  287.     { buf[i] = pad;
  288. #endif
  289.     }
  290.   
  291.   buf = writeCompressedInteger(num,buf + padding,len);
  292.   
  293.   return(buf);
  294. } 
  295.  
  296. /*----------------------------------------------------------------------*/
  297.  
  298. unsigned long
  299. writtenCompressedIntSize(num)
  300. unsigned long num;
  301. /* return the number of bytes needed to represnet the value num in
  302.    compressed format.  curently limited to 4 bytes
  303.  */
  304. {
  305.   if (num < CompressedInt1Byte) 
  306.     return(1);
  307.   else if (num < CompressedInt2Byte) 
  308.     return(2);
  309.   else if (num < CompressedInt3Byte)
  310.     return(3);
  311.   else
  312.     return(4);    
  313. }
  314.  
  315. /*----------------------------------------------------------------------*/
  316.  
  317. char*
  318. writeTag(tag,buf,len)
  319. data_tag tag;
  320. char* buf;
  321. long* len;
  322. /* write out a data tag */
  323. { 
  324.   return(writeCompressedInteger(tag,buf,len));
  325. } 
  326.  
  327. /*----------------------------------------------------------------------*/
  328.  
  329. char*
  330. readTag(tag,buf)
  331. data_tag* tag;
  332. char* buf;
  333. /* read a data tag */
  334. { 
  335.   return(readCompressedInteger(tag,buf));
  336. } 
  337.  
  338. /*----------------------------------------------------------------------*/
  339.  
  340. unsigned long 
  341. writtenTagSize(tag)
  342. data_tag tag;
  343. { 
  344.   return(writtenCompressedIntSize(tag));
  345. }
  346.  
  347. /*----------------------------------------------------------------------*/
  348.  
  349. data_tag
  350. peekTag(buf)
  351. char* buf;
  352. /* read a data tag without advancing the buffer */
  353. {
  354.   data_tag tag;
  355.   readTag(&tag,buf);
  356.   return(tag);
  357. } 
  358.  
  359. /*----------------------------------------------------------------------*/
  360.  
  361. any* 
  362. makeAny(size,data)
  363. unsigned long size;
  364. char* data;
  365. {
  366.   any* a = (any*)s_malloc((size_t)sizeof(any));
  367.   a->size = size;
  368.   a->bytes = data;
  369.   return(a);
  370. }
  371.  
  372. /*----------------------------------------------------------------------*/
  373.  
  374. void
  375. freeAny(a)
  376. any* a;
  377. /* destroy an any and its associated data. Assumes a->bytes was
  378.    allocated using the s_malloc family of libraries 
  379.  */
  380. {
  381.   if (a != NULL)
  382.     { if (a->bytes != NULL)
  383.         s_free(a->bytes);
  384.       s_free(a);
  385.     }
  386. }
  387.  
  388. /*----------------------------------------------------------------------*/
  389.  
  390. any* 
  391. duplicateAny(a)
  392. any* a;
  393. {
  394.   any* copy = NULL;
  395.  
  396.   if (a == NULL)
  397.     return(NULL);
  398.  
  399.   copy = (any*)s_malloc((size_t)sizeof(any));
  400.   copy->size = a->size;
  401.   if (a->bytes == NULL)
  402.     copy->bytes = NULL;
  403.   else
  404.     { copy->bytes = (char*)s_malloc((size_t)copy->size);
  405.       memcpy(copy->bytes,a->bytes,(size_t)copy->size);
  406.     }
  407.   return(copy);
  408. }
  409.  
  410. /*----------------------------------------------------------------------*/
  411.  
  412. char* 
  413. writeAny(a,tag,buffer,len)
  414. any* a;
  415. data_tag tag;
  416. char* buffer;
  417. long* len;
  418. /* write an any + tag and size info */
  419. {
  420.   char* buf = buffer;
  421.  
  422.   if (a == NULL)                /* handle unspecified optional args */
  423.     return(buf);
  424.   
  425.   /* write the tags */
  426.   buf = writeTag(tag,buf,len);
  427.   buf = writeCompressedInteger(a->size,buf,len);
  428.  
  429.   /* write the bytes */
  430. #ifdef WIN32
  431.   CHECK_FOR_SPACE_LEFT((long)(a->size),len);
  432. #else
  433.   CHECK_FOR_SPACE_LEFT(a->size,len);
  434. #endif
  435.   memcpy(buf,a->bytes,(size_t)a->size);
  436.  
  437.   return(buf+a->size);
  438. }
  439.  
  440. /*----------------------------------------------------------------------*/
  441.  
  442. char* 
  443. readAny(anAny,buffer)
  444. any** anAny;
  445. char* buffer;
  446. /* read an any + tag and size info */
  447. {
  448.   char* buf = buffer;
  449.   any* a = (any*)s_malloc((size_t)sizeof(any));
  450.   data_tag tag;
  451.   
  452.   buf = readTag(&tag,buf);
  453.   buf = readCompressedInteger(&a->size,buf);
  454.   /* now simply copy the bytes */
  455.   a->bytes = (char*)s_malloc((size_t)a->size);
  456.   memcpy(a->bytes,buf,(size_t)a->size);
  457.   *anAny = a;
  458.   return(buf+a->size);
  459. }
  460.  
  461. /*----------------------------------------------------------------------*/
  462.  
  463. unsigned long 
  464. writtenAnySize(tag,a)
  465. data_tag tag;
  466. any* a;
  467. {
  468.   unsigned long size;
  469.  
  470.   if (a == NULL)
  471.     return(0);
  472.  
  473.   size = writtenTagSize(tag);
  474.   size += writtenCompressedIntSize(a->size);
  475.   size += a->size;
  476.   return(size);
  477. }
  478.  
  479. /*----------------------------------------------------------------------*/
  480.  
  481. any*
  482. stringToAny(s)
  483. char* s;
  484. {
  485.   any* a = NULL;
  486.   
  487.   if (s == NULL)
  488.     return(NULL);
  489.     
  490.   a = (any*)s_malloc((size_t)sizeof(any));
  491.   a->size = strlen(s);
  492.   a->bytes = (char*)s_malloc((size_t)a->size);
  493.   memcpy(a->bytes,s,(size_t)a->size);
  494.   return(a);
  495. }
  496.  
  497. /*----------------------------------------------------------------------*/
  498.  
  499. char*
  500. anyToString(a)
  501. any* a;
  502. {
  503.   char* s = NULL;
  504.   
  505.   if (a == NULL)
  506.     return(NULL);
  507.     
  508.   s = s_malloc((size_t)(a->size + 1));
  509.   memcpy(s,a->bytes,(size_t)a->size);
  510.   s[a->size] = '\0';
  511.   return(s);
  512. }
  513.  
  514. /*----------------------------------------------------------------------*/
  515.  
  516. char* 
  517. writeString(s,tag,buffer,len)
  518. char* s;
  519. data_tag tag;
  520. char* buffer;
  521. long* len;
  522. /* Write a C style string.  The terminating null is not written. 
  523.    This function is not part of the Z39.50 spec.  It is provided
  524.    for the convienience of those wishing to pass C strings in 
  525.    the place of an any.
  526.  */
  527. {
  528.   char* buf = buffer;
  529.   any* data = NULL;
  530.   if (s == NULL)
  531.     return(buffer);             /* handle unused optional item before making an any */
  532.   data = (any*)s_malloc((size_t)sizeof(any)); 
  533.   data->size = strlen(s);
  534.   data->bytes = s;              /* save a copy here by not using stringToAny() */
  535.   buf = writeAny(data,tag,buf,len);
  536.   s_free(data);                 /* don't use freeAny() since it will free s too */
  537.   return(buf);
  538. }
  539.  
  540. /*----------------------------------------------------------------------*/
  541.  
  542. char* 
  543. readString(s ,buffer)
  544. char** s ;
  545. char* buffer;
  546. /* Read an any and convert it into a C style string.
  547.    This function is not part of the Z39.50 spec.  It is provided
  548.    for the convienience of those wishing to pass C strings in 
  549.    the place of an any. 
  550.  */
  551. {
  552.   any* data = NULL;
  553.   char* buf = readAny(&data,buffer);
  554.   *s = anyToString(data);
  555.   freeAny(data);
  556.   return(buf);
  557. }
  558.  
  559. /*----------------------------------------------------------------------*/
  560.  
  561. unsigned long 
  562. writtenStringSize(tag,s)
  563. data_tag tag;
  564. char* s;
  565. {
  566.   unsigned long size;
  567.  
  568.   if (s == NULL)
  569.    return(0);
  570.  
  571.   size = writtenTagSize(tag);
  572.   size += writtenCompressedIntSize(size);
  573.   size += strlen(s);
  574.   return(size);
  575. }
  576.  
  577. /*----------------------------------------------------------------------*/
  578.  
  579. any* 
  580. longToAny(num)
  581. long num;
  582. /* a convienience function */
  583. {
  584.   char s[40];
  585.  
  586.   sprintf(s,"%ld",num);
  587.   
  588.   return(stringToAny(s));
  589. }
  590.  
  591. /*----------------------------------------------------------------------*/
  592.  
  593. long
  594. anyToLong(a)
  595. any* a;
  596. /* a convienience function */
  597. {
  598.   long num;
  599.   char* str = NULL;
  600.   str = anyToString(a);
  601.   sscanf(str,"%ld",&num);       /* could check the result and return
  602.                                    an error */
  603.   s_free(str);
  604.   return(num);
  605. }
  606.  
  607. /*----------------------------------------------------------------------*/
  608.  
  609. #define bitsPerByte     8
  610.  
  611. #ifdef ANSI_LIKE /* use ansi */
  612.  
  613. bit_map*
  614. makeBitMap(unsigned long numBits,...)
  615. /* construct and return a bitmap with numBits elements */
  616. {
  617.   va_list ap;
  618.   long i,j;
  619.   bit_map* bm = NULL;
  620.  
  621.   va_start(ap,numBits);
  622.   
  623.   bm = (bit_map*)s_malloc((size_t)sizeof(bit_map));
  624.   bm->size = (unsigned long)ceil((double)numBits / bitsPerByte); 
  625.   bm->bytes = (char*)s_malloc((size_t)bm->size);
  626.   
  627.   /* fill up the bits */
  628. #ifdef WIN32
  629.   for (i = 0; i < (long)(bm->size); i++) /* iterate over bytes */
  630. #else
  631.   for (i = 0; i < bm->size; i++) /* iterate over bytes */
  632. #endif
  633.     { char byte = 0;
  634.       for (j = 0; j < bitsPerByte; j++) /* iterate over bits */
  635. #ifdef WIN32
  636.         { if ((i * bitsPerByte + j) < (long)numBits)
  637. #else
  638.         { if ((i * bitsPerByte + j) < numBits)
  639. #endif
  640.             { boolean bit = false;
  641.               bit = (boolean)va_arg(ap,boolean); 
  642.               if (bit)
  643.                 { byte = byte | (1 << (bitsPerByte - j - 1));
  644.                 }
  645.             }
  646.           }
  647.       bm->bytes[i] = byte;
  648.     }
  649.  
  650.   va_end(ap);
  651.   return(bm);
  652. }
  653.  
  654. #else /* use K & R */
  655.  
  656. bit_map*
  657. makeBitMap(va_alist)
  658. va_dcl
  659. /* construct and return a bitmap with numBits elements */
  660. {
  661.   va_list ap;
  662.   long i,j;
  663.   unsigned long numBits;
  664.   bit_map* bm = (bit_map*)s_malloc((size_t)sizeof(bit_map));
  665.  
  666.   va_start(ap);
  667.   
  668.   numBits = va_arg(ap,unsigned long);
  669.  
  670.   bm->size = (unsigned long)ceil((double)numBits / bitsPerByte);
  671.   
  672.   bm->bytes = (char*)s_malloc((size_t)bm->size);
  673.   
  674.   /* fill up the bits */
  675.   for (i = 0; i < bm->size; i++) /* iterate over bytes */
  676.     { char byte = 0;
  677.       for (j = 0; j < bitsPerByte; j++) /* iterate over bits */
  678.         { if ((i * bitsPerByte + j) < numBits)
  679.             { boolean bit;
  680.               bit = (boolean)va_arg(ap,int); /* really boolean, but this 
  681.                                                 is how it is passed on stack */
  682.               if (bit)
  683.                 { byte = byte | (1 << (bitsPerByte - j - 1));
  684.                 }
  685.             }
  686.           }
  687.       bm->bytes[i] = byte;
  688.     }
  689.  
  690.   va_end(ap);
  691.  
  692.   return(bm);
  693. }
  694.  
  695. #endif 
  696.  
  697. /*----------------------------------------------------------------------*/
  698.  
  699. void
  700. freeBitMap(bm)
  701. bit_map* bm;
  702. /* destroy a bit map created by makeBitMap() */
  703. {
  704.   s_free(bm->bytes);
  705.   s_free(bm);
  706. }
  707.  
  708. /*----------------------------------------------------------------------*/
  709.  
  710. /* use this routine to interpret a bit map.  pos specifies the bit 
  711.    number.  bit 0 is the Leftmost bit of the first byte.  
  712.    Could do bounds checking.
  713.  */
  714.  
  715. boolean
  716. bitAtPos(pos,bm)
  717. long pos;
  718. bit_map* bm;
  719. {
  720. #ifdef WIN32
  721.   if (pos > (long)(bm->size*bitsPerByte))
  722. #else
  723.   if (pos > bm->size*bitsPerByte)
  724. #endif
  725.     return false;
  726.   else
  727.     return((bm->bytes[(pos / bitsPerByte)] & 
  728.             (0x80>>(pos % bitsPerByte))) ?
  729.            true : false);
  730. }
  731.  
  732. /*----------------------------------------------------------------------*/
  733.  
  734. char*
  735. writeBitMap(bm,tag,buffer,len)
  736. bit_map* bm;
  737. data_tag tag;
  738. char* buffer;
  739. long* len;
  740. /* write a bitmap + type and size info */
  741. { 
  742.   return(writeAny((any*)bm,tag,buffer,len));
  743. }
  744.  
  745. /*----------------------------------------------------------------------*/
  746.  
  747. char*
  748. readBitMap(bm,buffer)
  749. bit_map** bm;
  750. char* buffer;
  751. /* read a bitmap + type and size info */
  752. { 
  753.   return(readAny((any**)bm,buffer));
  754. }
  755.  
  756. /*----------------------------------------------------------------------*/
  757.  
  758. char* 
  759. writeByte(byte,buf,len)
  760. unsigned long byte;
  761. char* buf;
  762. long* len;
  763. {
  764.   CHECK_FOR_SPACE_LEFT(1L,len);
  765. #ifdef WIN32
  766.   buf[0] = (char)(byte & 0xFF); /* we really only want the first byte */
  767. #else
  768.   buf[0] = byte & 0xFF; /* we really only want the first byte */
  769. #endif
  770.   return(buf + 1);
  771. }
  772.  
  773. /*----------------------------------------------------------------------*/
  774.  
  775. char* 
  776. readByte(byte,buf)
  777. unsigned char* byte;
  778. char* buf;
  779. {
  780.   *byte = buf[0];
  781.   return(buf + 1);
  782. }
  783.  
  784. /*----------------------------------------------------------------------*/
  785.  
  786. char* 
  787. writeBoolean(flag,buf,len)
  788. boolean flag;
  789. char* buf;
  790. long* len;
  791. {
  792.   return(writeByte(flag,buf,len));
  793. }
  794.  
  795. /*----------------------------------------------------------------------*/
  796.  
  797. char* 
  798. readBoolean(flag,buffer)
  799. boolean* flag;
  800. char* buffer;
  801. {
  802.   unsigned char byte;
  803.   char* buf = readByte(&byte,buffer);
  804.   *flag = (byte == true) ? true : false;
  805.   return(buf);
  806. }
  807.  
  808. /*----------------------------------------------------------------------*/
  809.  
  810. char*
  811. writePDUType(pduType,buf,len)
  812. pdu_type pduType;
  813. char* buf;
  814. long* len;
  815. /* PDUType is a single byte */
  816. {
  817.   return(writeBinaryInteger((long)pduType,(unsigned long)1,buf,len));
  818. } 
  819.  
  820. /*----------------------------------------------------------------------*/
  821.  
  822. char*
  823. readPDUType(pduType,buf)
  824. pdu_type* pduType;
  825. char* buf;
  826. /* PDUType is a single byte */
  827. {
  828.   return(readBinaryInteger((long*)pduType,(unsigned long)1,buf));
  829. } 
  830.  
  831. /*----------------------------------------------------------------------*/
  832.  
  833. pdu_type
  834. peekPDUType(buf)
  835. char* buf;
  836. /* read the next pdu without advancing the buffer, Note that this 
  837.    function is to be used on a buffer that is known to contain an
  838.    APDU.  The pdu_type is written HEADER_LEN bytes into the buffer
  839.  */
  840. {
  841.   pdu_type pdu;
  842.   readPDUType(&pdu,buf + HEADER_LEN);
  843.   return(pdu);
  844. }
  845.  
  846. /*----------------------------------------------------------------------*/
  847.  
  848. #define BINARY_INTEGER_BYTES    sizeof(long) /* the number of bytes used by
  849.                                                 a "binary integer" */
  850. char*
  851. writeBinaryInteger(num,size,buf,len)
  852. long num;
  853. unsigned long size;
  854. char* buf;
  855. long* len;
  856. /* write out first size bytes of num - no type info
  857.   XXX should this take unsigned longs instead ???  */
  858. {
  859.   long i;
  860.   char byte;
  861.  
  862.   if (size < 1 || size > BINARY_INTEGER_BYTES)
  863.     return(NULL);               /* error */
  864.  
  865. #ifdef WIN32
  866.   CHECK_FOR_SPACE_LEFT((long)size,len);
  867. #else
  868.   CHECK_FOR_SPACE_LEFT(size,len);
  869. #endif
  870.  
  871.   for (i = size - 1; i >= 0; i--)
  872.     { byte = (char)(num & 255);
  873.       buf[i] = byte;
  874.       num = num >> bitsPerByte; /* don't and here */
  875.     }
  876.  
  877.   return(buf + size);
  878. }
  879.  
  880. /*----------------------------------------------------------------------*/
  881.  
  882. char*
  883. readBinaryInteger(num,size,buf)
  884. long* num;
  885. unsigned long size;
  886. char* buf;
  887. /* read in first size bytes of num - no type info
  888.   XXX this should take unsigned longs instead !!! */
  889. {
  890.   long i;
  891.   unsigned char byte;
  892.   if (size < 1 || size > BINARY_INTEGER_BYTES)
  893.     return(buf);                /* error */
  894.   *num = 0;
  895. #ifdef WIN32
  896.   for (i = 0; i < (long)size; i++)
  897. #else
  898.   for (i = 0; i < size; i++)
  899. #endif
  900.     { byte = buf[i];
  901.       *num = *num << bitsPerByte;
  902.       *num += byte;
  903.     }
  904.   return(buf + size);
  905. }
  906.  
  907. /*----------------------------------------------------------------------*/
  908.  
  909. unsigned long 
  910. writtenCompressedBinIntSize(num)
  911. long num;
  912. /* return the number of bytes needed to represent the value num.
  913.    currently limited to max of 4 bytes 
  914.    Only compresses for positive nums - negatives get whole 4 bytes
  915.  */
  916. {
  917.   if (num < 0L)
  918.     return(4);
  919.   else if (num < 256L)          /* 2**8 */
  920.     return(1);
  921.   else if (num < 65536L)        /* 2**16 */
  922.     return(2);
  923.   else if (num < 16777216L)     /* 2**24 */
  924.     return(3);
  925.   else
  926.     return(4);
  927. }
  928.  
  929. /*----------------------------------------------------------------------*/
  930.  
  931. char*
  932. writeNum(num,tag,buffer,len)
  933. long num;
  934. data_tag tag;
  935. char* buffer;
  936. long* len;
  937. /* write a binary integer + size and tag info */
  938. {
  939.   char* buf = buffer;
  940.   long size = writtenCompressedBinIntSize(num);
  941.   
  942.   if (num == UNUSED)
  943.     return(buffer);
  944.     
  945.   buf = writeTag(tag,buf,len);
  946.   buf = writeCompressedInteger(size,buf,len); 
  947.   buf = writeBinaryInteger(num,(unsigned long)size,buf,len); 
  948.   return(buf);
  949. }
  950.  
  951. /*----------------------------------------------------------------------*/
  952.  
  953. char*
  954. readNum(num,buffer)
  955. long* num;
  956. char* buffer;
  957. /* read a binary integer + size and tag info */
  958. {
  959.   char* buf = buffer;
  960.   data_tag tag;
  961.   unsigned long size;
  962.   unsigned long val;
  963.   
  964.   buf = readTag(&tag,buf);
  965.   buf = readCompressedInteger(&val,buf);
  966.   size = (unsigned long)val;
  967.   buf = readBinaryInteger(num,size,buf);
  968.   return(buf);
  969. }
  970.  
  971. /*----------------------------------------------------------------------*/
  972.  
  973. unsigned long 
  974. writtenNumSize(tag,num)
  975. data_tag tag;
  976. long num;
  977. {
  978.   long dataSize = writtenCompressedBinIntSize(num);
  979.   long size;
  980.   
  981.   size = writtenTagSize(tag); /* space for the tag */
  982.   size += writtenCompressedIntSize(dataSize); /* space for the size */
  983.   size += dataSize; /* space for the data */
  984.   
  985.   return(size);
  986. }
  987.  
  988. /*----------------------------------------------------------------------*/
  989.  
  990. typedef void (voidfunc)();
  991.  
  992. void
  993. doList(list,func)
  994. void** list;
  995. voidfunc *func;
  996. /* call func on each element of the NULL terminated list of pointers */
  997. {
  998.   register long i;
  999.   register void* ptr = NULL;
  1000.   if (list == NULL)
  1001.     return;
  1002.   for (i = 0,ptr = list[i]; ptr != NULL; ptr = list[++i])
  1003.     (*func)(ptr);
  1004. }
  1005.  
  1006. /*----------------------------------------------------------------------*/
  1007.  
  1008. char* 
  1009. writeProtocolVersion(buf,len)
  1010. char* buf;
  1011. long* len;
  1012. /* write a bitmap describing the protocols available */
  1013. {
  1014.   static bit_map* version = NULL;
  1015.  
  1016.   if (version == NULL)
  1017.    { version = makeBitMap((unsigned long)1,true); /* version 1! */
  1018.    }
  1019.     
  1020.   return(writeBitMap(version,DT_ProtocolVersion,buf,len));
  1021. }
  1022.  
  1023. /*----------------------------------------------------------------------*/
  1024.  
  1025. char*
  1026. defaultImplementationID()
  1027. {
  1028.   static char   ImplementationID[] = "TMC";
  1029.   return(ImplementationID);
  1030. }
  1031.  
  1032. /*----------------------------------------------------------------------*/
  1033.  
  1034. char*
  1035. defaultImplementationName()
  1036. {
  1037.   static char ImplementationName[] = "Thinking Machines Corporation Z39.50";
  1038.   return(ImplementationName);
  1039. }
  1040.  
  1041. /*----------------------------------------------------------------------*/
  1042.  
  1043. char*
  1044. defaultImplementationVersion()
  1045. {
  1046.   static char   ImplementationVersion[] = "2.0A";
  1047.   return(ImplementationVersion);
  1048. }
  1049.  
  1050. /*----------------------------------------------------------------------*/
  1051.  
  1052.